#include <vcl.h>
#include <EIC.h>
#pragma hdrstop

#include "CEditCpt.h"
#pragma link "CEdit"
#pragma package(smart_init)
//---------------------------------------------------------------------------
// ValidCtrCheck est utilisé pour être sûr que les composants créés ne
// contiennent aucune fonction virtuelle pure.
//

static inline void ValidCtrCheck(CEditCompte *)
{
    new CEditCompte(NULL);
}
//---------------------------------------------------------------------------
namespace Ceditcpt
{
    void __fastcall PACKAGE Register()
    {
        TComponentClass classes[1] = {__classid(CEditCompte)};
        RegisterComponents("EIC Ctrlstd", classes, 0);
    }
}
//---------------------------------------------------------------------------

TCompleteCompte CEditCompte::CM_CompleteCompte = NULL;
TTrouveCompte CEditCompte::CM_TrouveCompte = NULL;

//*******************//
// Class CEditCompte //
//*******************///////////////////////////////////////////////////////////
//                                                                            //
//    Cette classe implémente un control de saisie/affichage d'un compte (sur //
// 13 positions alphanumériques).                                             //
//                                                                            //
// PARTICULARITÉS :                                                           //
//    La saisie est alphanumérique en majuscules et limitée à 13 caractères   //
// sachant que le premier doit être une classe de compte valide ('1' à '8',   //
// 'C' ou 'F'). Les classes '0' et '9' sont automatiquement converties en     //
// classe Client/Fournisseur selon le paramétrage choisi.                     //
//                                                                            //
// Note: Dérive, de CEditBase, ce control redirige toutes les saisies de      //
//       façon à contrôler totalement ce processus.                           //
////////////////////////////////////////////////////////////////////////////////
__fastcall CEditCompte::CEditCompte( TComponent* pOwner)
: inherited( pOwner)
{
 inherited::Filtres      << feTotal;       // Pour contrôler toute la saisie (notemment la classe du compte et le caractère alphanumérique des comptes centralisateurs)
 inherited::OnIllegalChar = OnIllegalChar; // Filtre clavier
 CharCase                 = ecUpperCase;
 MaxLength                = 13;
 Width                    = 105;
 m_bCompleteCompte        = true;
 m_bAccepteCompteAbrege   = false;
} /* CEditCompte::CEditCompte() */


/*----------------------------------------------------------------------------*\
------------- CEditCompte::OnIllegalChar() -------------------------------------
--------------------------------------------------------------------------------
-                                                                              -
-    Cette méthode permet de filtrer les classes de comptes et l'autorisation  -
- alpha/numérique en fonction de cette classe.                                 -
-                                                                              -
- Paramètres :                                                                 -
-   pedSender        : Le control de saisie du compte.                         -
-   cIllegalCharCode : Code (virtuel) du caractère à saisir.                   -
-   bAccept          : Positionner à true pour accepter le caractère           -
-                      (éventuellemnt modifié) en saisie.                      -
-                                                                              -
- Notes : * Un caractère refusé provoque un beep pour avertir l'utilisateur.   -
-         * L'acceptation du caractère '\0' n'a aucun effet sur la saisie.     -
\*----------------------------------------------------------------------------*/
void __fastcall CEditCompte::OnIllegalChar( CCustomEdit* pedSender,
                                            Word&        cIllegalCharCode,
                                            bool&        bAccept)
{
 int  nSelStart;    // Position  du début de la sélection
 int  nSelStop;     //    "     de la fin "  "     "
// char szClasse[ 2]; // Classe du compte actuellement dans le control (son 1er caractère)


 ////////////////////////////////////
 // Filtrage des touches spéciales //
 ////////////////////////////////////
 if( cIllegalCharCode == VK_BACK)
 { // Effacement standard autorisé
   bAccept = true;
   return;
 }


 /////////////////////////////////////////////////////////////////////////
 // Lecture des caractéristiques du compte actuellement dans le control //
 /////////////////////////////////////////////////////////////////////////
 #if( sizeof( DWORD) != sizeof( int))
  #error *** sizeof() incompatibles avec les variables automatiques... ***
 #endif
 Perform( EM_GETSEL, (WPARAM)&nSelStart, (LPARAM)&nSelStop);
 if( nSelStart == 0)
 { ///////////////////////////////////
   // Saisie de la classe du compte //
   ///////////////////////////////////
   //if( ( cIllegalCharCode >= '1') && ( cIllegalCharCode <= '8'))
   if((( cIllegalCharCode>='1') && ( cIllegalCharCode<='9')) || (m_bAccepteCompteAbrege && (cIllegalCharCode == '.' || cIllegalCharCode == ';')) /*&& ( cIllegalCharCode!='8')*/)
     bAccept = true;
/*
   if( ( nSelStop - nSelStart) == GetTextLen())
   { // Le contrôle est vide ou bien entièrement sélectionné
     // => Filtre sur la classe d'un compte
     if( ( ( cIllegalCharCode >= '1') && ( cIllegalCharCode <= '8')) ||
         ( cIllegalCharCode == 'C')                                  ||
         ( cIllegalCharCode == 'F'))
       bAccept = true;
   }
   else
   { // L'utilisateur souhaite remplacer (ou insérer) la classe du compte
     // => Autorisation seulement pour les classes centralisées (pour éviter une analyse sur les caractères du compte)
     if( ( cIllegalCharCode == 'C') || ( cIllegalCharCode == 'F'))
       bAccept = true;
   }
*/
 }
 else
 { /////////////////////////////////////
   // Saisie d'un caractère du compte //
   /////////////////////////////////////
if( ( ( cIllegalCharCode >= 'A') && ( cIllegalCharCode <= 'Z')) ||
    ( ( cIllegalCharCode >= '0') && ( cIllegalCharCode <= '9')))
  bAccept = true;
/*
   Perform( WM_GETTEXT, (WPARAM)sizeof( szClasse), (LPARAM)&szClasse);
   switch( *szClasse)
   { // Classe "Clients" ou "Fournisseurs"
     // => Ces comptes peuvent être alphanumériques
     case 'C'  :
     case 'F'  :
       if( ( ( cIllegalCharCode >= 'A') && ( cIllegalCharCode <= 'Z')) ||
           ( ( cIllegalCharCode >= '0') && ( cIllegalCharCode <= '9')))
         bAccept = true;
       break;

     // Classes standard
     // => Comptes numériques uniquement
     default   :
       if( ( cIllegalCharCode >= '0') && ( cIllegalCharCode <= '9'))
         bAccept = true;
       break;
   }
*/
 }
} /* CEditCompte::OnIllegalCharCompte() */


/******************************************************************************\
************* CEditCompte::IsEmpty() *******************************************
********************************************************************************
*                                                                              *
*    Cette méthode (virtuelle) permet de savoir si le control contient un      *
* compte vide i.e. ne contient rien ou seulement une classe de compte          *
* centralisateur (qui ne représenta pas un vrai compte en soi).                *
*                                                                              *
* Retour :                                                                     *
*   TRUE si le control ne contient pas un vrai compte; FALSE sinon.            *
\******************************************************************************/
bool __fastcall CEditCompte::IsEmpty( void)
{
// char szDebutCompte[ 3]; // Les 2 1ers caractères du compte


 if( GetTextLen() == 0)
 { // Le control est complètement vide
   return true;
 }
/*
 else
 { // Lecture des premiers caractères du compte
   Perform( WM_GETTEXT, (WPARAM)sizeof( szDebutCompte), (LPARAM)&szDebutCompte);
   if( szDebutCompte[ 1] == '\0')
   { // Le compte ne contient qu'un caractère
     if( ( *szDebutCompte == 'C') || ( *szDebutCompte == 'F'))
     { // Le control ne contient qu'une indication de compte centralisé
       // => Ce n'est pas un vrai compte
       return( true);
     }
   }
 }
*/

 // Le control ne représente pas un compte vide
 return false;
} /* CEditCompte::IsEmpty() */

void __fastcall CEditCompte::CMExit( TMessage &Msg)
{
  if (CM_TrouveCompte && m_bAccepteCompteAbrege && Text.Length() > 1 && (Text[1] == '.' || Text[1] == ';'))
    Compte = CM_TrouveCompte(Compte);
  if ( CM_CompleteCompte && m_bCompleteCompte)
    Compte = CM_CompleteCompte( Compte);
  inherited::Dispatch( &Msg);
}


bool __fastcall EstCompteComprisEntre( const AnsiString &strCompte, const AnsiString &strCptA, const AnsiString &strCptB)
{
  AnsiString strCpt1, strCpt2;

  if (strCptA.IsEmpty() || strCptB.IsEmpty()) return false;

  strCpt1 = strCompte.SubString( 1, strCptA.Length());
  strCpt2 = strCompte.SubString( 1, strCptB.Length());

  return (( strcmp( strCpt1.c_str(), strCptA.c_str())>=0) &&
          ( strcmp( strCpt2.c_str(), strCptB.c_str())<=0));
}

